"""
海龟绘图很适合用来引导初学者学习编程。想象一个小乌龟，在一个横轴为 x、纵轴为 y 的
坐标系原点 (0,0) 位置开始，根据一组指令的控制，在这个平面坐标系中移动，其爬行的路
径就是所绘制的图形。

中文颜色字符串可输入: '红色', '黄色', '蓝色', '黑色', '白色', '灰色', '绿色',
'紫色', '橙色', '洋红', '海贝色', '粉红', '棕色', '金色', '银色', '青色', '番茄色'.\n
内置海龟形状中文名有: '箭头', '海龟', '圆形', '方形', '三角形', '经典', '空白'.

----- turtle.py

海龟模块提供面向对象和面向过程两种形式的编程。面向对象的接口主要有屏幕类和海龟
类两个类。过程式接口提供与屏幕类和海龟类的方法相对应的函数。函数名与类对应的方
法名相同。当屏幕类的方法对应函数被调用时会自动创建一个屏幕对象。屏幕类是单例类，
即程序运行期间只允许存在它的一个实例。当海龟类的方法对应函数被调用时会自动创建
一个匿名的海龟对象。如果屏幕上需要有多个海龟，就需要使用<海龟类()>。

"""

_原始版本 = "turtle 1.1b- - for Python 3.1   -  4. 5. 2009"
_汉化版本 = "2020.02.04 - 草蟒380 - 2019.11.29"
_汉化人 = "老吴"

导入 turtle
从 typing 导入 TypeVar

_tg_类 = ['海龟类', '形状类', '二维向量类']
_tg_屏幕函数 = ['添加形状', '背景颜色', '背景图片', '再见',
        '清屏', '颜色模式', '延迟', '当点击时退出', '获取画布',
        '获取形状', '监听', '主循环', '模式', '数字输入',
        '当键盘按下', '当键盘释放', '当点击屏幕', '当达到定时',
        '重置屏幕', '屏幕大小', '设置',
        '设置世界坐标系', '文本输入', '标题', '示踪', '所有海龟', '更新',
        '窗口高度', '窗口宽度']
_tg_海龟函数 = ['后退', '开始填充', '开始记录多边形',
        '画圆', '清除', '清除印章', '清除多个印章', '克隆', '颜色',
        '设置圆度数', '距离', '画点', '画笔落下', '结束填充', '结束记录多边形', '前进',
        '填充颜色', '是否在填充', '获取多边形', '获取海龟', '获取屏幕', '获取形状多边形',
        '前往', '朝向', '隐藏海龟', '回到原点', '画笔是否落下',
        '是否可见', '左转', '当点击鼠标', '当拖动鼠标', '当释放鼠标', 
        '画笔', '画笔颜色', '画笔粗细', '画笔抬起', '位置',
        '弧度制', '右转', '重置', '大小调整模式', 
        '设置朝向', '设置倾角',
        '设置撤消缓冲区', '设置x', '设置y', '形状', '形状大小', '变形', '剪切因子', '显示海龟',
        '速度', '印章', '倾斜', '目标方向',
        '撤消', '撤消缓冲区条目数', 
        '书写', 'x坐标', 'y坐标']
_tg_实用工具 = ['完成']

__all__ = (_tg_类 + _tg_屏幕函数 + _tg_海龟函数 +
           _tg_实用工具) # + _math_functions)

类 二维向量类(turtle.Vec2D):
    """帮助实现海龟绘图体系的二维向量类。
    对海龟绘图程序可能也有用。
    从元组派生，因此向量就是元组！

    提供如下操作 (a、b 为向量，k 为数)：
       a+b 向量加法
       a-b 向量减法
       a*b 内积
       k*a 和 a*k 数乘
       |a| a 的绝对值
       a.旋转(角度) 旋转
    """
    函 旋转(自身, 角度):
        """自身逆时针旋转给定角度
        """
        返回 自身.rotate(角度)

_颜色字典 = {
    '红色': 'red',
    '黄色': 'yellow',
    '蓝色': 'blue',
    '黑色': 'black',
    '白色': 'white',
    '灰色': 'grey',
    '绿色': 'green',
    '紫色': 'purple',
    '橙色': 'orange',
    '洋红': 'magenta',
    '海贝色': 'seashell',
    '粉红': 'pink',
    '棕色': 'brown',
    '金色': 'gold',
    '银色': 'silver',
    '青色': 'cyan',
    '番茄色': 'tomato',
}

_颜色字典英中 = 字典([值, 键] 取 键, 值 于 _颜色字典.项())

_形状字典 = {
    '箭头': 'arrow',
    '海龟': 'turtle',
    '圆形': 'circle',
    '方形': 'square',
    '三角形': 'triangle',
    '经典': 'classic',
    '空白': 'blank'
}

_形状字典英中 = 字典([值, 键] 取 键, 值 于 _形状字典.项())

_调整模式字典 = 字典(自动='auto', 用户='user', 不调整='noresize')
_调整模式字典英中=字典(auto='自动', user='用户', noresize='不调整')

_按键字典 = {    # 不全面, 有待补充
    '上': 'Up', # 上箭头键, 以下类似
    '下': 'Down',
    '左': 'Left',
    '右': 'Right',
    '空格': 'space'
}

类 海龟异常(Exception):
    无操作

类 形状类(turtle.Shape):
    '''模拟形状的数据结构. 用于创建新的海龟形状。类型有三种：\n
    '多边形'、'图片' 和 '复合'.\n
    对应的数据分别为多边形元组（即由坐标值对构成的元组）、图片（仅限内部使用）和 <空>.\n
    复合形状必须使用 <添加组件()> 方法来构建.
    '''
    函 __init__(自身, 类型_, 数据=空):
        类型字典 = 字典(多边形='polygon', 图片='image', 复合='compound')
        类型_ = 类型字典.获取(类型_, 类型_)
        自身._type = 类型_
        如果 类型_ == "polygon":
            如果 是实例(数据, 列表):
                数据 = 元组(数据)
        或如 类型_ == "image":
            如果 是实例(数据, 串):
                如果 数据.小写().结尾是(".gif") 且 turtle.isfile(数据):
                    数据 = turtle.TurtleScreen._image(数据)
                # else data assumed to be Photoimage
        或如 类型_ == "compound":
            数据 = []
        否则:
            报 turtle.TurtleGraphicsError("没有 %s 类型的形状" % 类型_)
        自身._data = 数据

    函 添加组件(自身, 多边形, 填充颜色, 轮廓颜色=空):
        '''将组件添加到<复合>类型的形状.
        多边形用数值对组成的元组表示.
        '''
        如果 自身._type != "compound":
            报 turtle.TurtleGraphicsError("无法添加组件到 %s 形状"
                                                                % 自身._type)
        填充颜色 = _颜色字典.获取(填充颜色, 填充颜色)
        如果 轮廓颜色 是 空:
            轮廓颜色 = 填充颜色
        否则:
            轮廓颜色 = _颜色字典.获取(轮廓颜色, 轮廓颜色)
        自身._data.追加([多边形, 填充颜色, 轮廓颜色])


# 屏幕相关操作部分

函 文本输入(标题, 提示语):
    '''弹出一个对话框, 用于输入字符串。
    <标题>为对话框窗口的标题，<提示语>通常用来提示要输入什么信息。
    返回输入的字符串。如果对话框被取消则返回空。
    '''
    返回 turtle.textinput(标题, 提示语)

函 数字输入(标题, 提示语, 默认值=空, 最小=空, 最大=空):
    '''弹出一个对话框, 用于输入数值。
    输入值必须在指定的<最小>到<最大>范围内，
    否则将给出一条提示，对话框保持打开等待修改。
    返回输入的数值。如果对话框被取消则返回空。
    '''
    返回 turtle.numinput(标题, 提示语, 默认值, 最小, 最大)

函 清屏():
    '''删除屏幕上的所有绘图和海龟。
    将屏幕重置为初始状态: 白色背景，无背景图片，
    无事件绑定，启用示踪。'''
    turtle.Screen().clear()

函 模式(模式=空):
    '''设置海龟初始模式 (<朝右>、<朝上> 或 <世界>) 并重置。
    如未指定模式则返回当前模式。\n
    <朝右> ('standard')：海龟初始方向为朝右，逆时针旋转为正数角度。\n
    <朝上> ('logo')：海龟初始方向为朝上，顺时针旋转为正数角度。\n
    <世界> ('world'): 使用用户自定义的"世界坐标系".
    '''
    模式字典 = 字典(朝右='standard', 朝上='logo', 世界='world')
    模式字典英中 = 字典(standard='朝右', logo='朝上', world='世界')
    如果 模式 是 空:
        返回 模式字典英中[turtle.mode()]
    否则:
        如果 模式 不在 ['朝右', '朝上', '世界', "standard", "logo", "world"]:
            报 turtle.TurtleGraphicsError("没有名为 %s 的海龟绘图模式" % 模式)
        否则:
            模式 = 模式字典.获取(模式, 模式)
            turtle.mode(模式) 

函 设置世界坐标系(画布左下角x坐标, 画布左下角y坐标, 画布右上角x坐标,
                画布右上角y坐标):
    '''设置用户自定义坐标系，方便构图；此设置会执行一次屏幕重置.
    '''
    turtle.setworldcoordinates(画布左下角x坐标, 画布左下角y坐标, 画布右上角x坐标,
                画布右上角y坐标)

函 添加形状(名称, 形状=空):
    '''给海龟屏幕类的形状列表添加一个海龟形状.\n
    此函数有三种调用方式。1) 名称为一个 gif 文件的文件名，形状为空；
    例如：海龟.添加形状('五角星.gif')。2) 名称为一个字符串，
    形状为由坐标值对构成的元组；例如：海龟.添加形状('钻石', ((5, -10), (15, 10), (-5, 10), (-15, -10)))。
    3) 名称为一个字符串，形状为形状类对象.\n
    要使用所添加的形状, 须发出命令 <形状(名称)>.
    '''
    turtle.register_shape(名称, 形状)

函 颜色模式(模式值=空):
    '''返回颜色模式（无参数时）或将其设为 1.0 或 255。\n
    构成颜色三元组的 r, g, b 数值必须在 0 到<模式值>范围内。
    '''
    返回 turtle.colormode(模式值)

函 重置屏幕():
    '''将屏幕上的所有海龟重置到其初始状态.'''
    turtle.Screen().reset()

函 所有海龟():
    '''返回屏幕上的海龟列表.'''
    返回 turtle.turtles()

函 背景颜色(*参数):
    '''设置或返回海龟屏幕的背景颜色.
    参数 (如有) 可以是颜色字符串或三元颜色值.'''
    如果 长(参数) == 1:  # 可能是中文颜色字符串
        试:
            参数_ = _颜色字典[参数[0]]
            返回 turtle.bgcolor(参数_)
        捕:
            无操作
    返回 turtle.bgcolor(*参数)

函 示踪( n=空, 延迟值=空):
    '''启用/禁用 (n 设置为 0) 海龟动画并设置刷新图形的延迟时间。\n
    如果指定 n 值，则只有每第 n 次屏幕刷新会实际执行。\n
    如果调用时不带参数，则返回当前保存的 n 值。\n
    第二个参数设置延迟值，同<延迟(延迟值)>。'''
    返回 turtle.tracer(n, 延迟值)

函 延迟(延迟值=空):
    '''设置或返回以毫秒数表示的延迟值。延迟越长，动画速度越慢。
    默认延迟值为 10 毫秒。'''
    返回 turtle.delay(延迟值)

函 更新():
    '''执行一次屏幕刷新。在禁用示踪时使用。'''
    turtle.update()

函 窗口宽度():
    '''返回海龟窗口的宽度.'''
    返回 turtle.window_width()

函 窗口高度():
    '''返回海龟窗口的高度.'''
    返回 turtle.window_height()

函 获取画布():
    '''返回海龟屏幕的画布.'''
    返回 turtle.getcanvas()

函 获取形状():
    '''返回当前所有可用海龟形状的列表.'''
    返回 [_形状字典英中.获取(形状, 形状) 取 形状 于 turtle.getshapes()]

函 当点击屏幕(函数名, 按键=1, 是否添加绑定=空):
    '''将函数绑定到鼠标点击画布事件.'''
    turtle.onscreenclick(函数名, 按键, 是否添加绑定)

函 当键盘释放(函数名, 按键):
    '''将函数绑定到指定键的释放事件.\n
    如果函数名为空，则移除事件绑定。'''
    按键 = _按键字典.获取(按键, 按键)
    turtle.onkey(函数名, 按键)

函 当键盘按下(函数名, 按键=空):
    '''将指定函数绑定到指定键的按下事件。\n
    如未指定键，则绑定到任意键的按下事件。'''
    按键 = _按键字典.获取(按键, 按键)
    turtle.onkeypress(函数名, 按键)

函 监听(哑x=空, 哑y=空):
    '''设置焦点到屏幕以便接收按键事件。'''
    turtle.listen(哑x, 哑y)

函 当达到定时(函数名, t=0):
    '''设置一个计时器，在 t 毫秒后调用指定函数。'''
    turtle.ontimer(函数名, t)

函 背景图片(图片名=空):
    '''设置背景图片或返回当前背景图片的名称.\n
    <图片名> 可以是 gif 文件名或 "无图" ("nopic").\n
    如果是文件名, 则将相应图片设为背景.\n
    如果是 "无图", 则删除背景图片(如有).\n
    如果是<空>, 则返回当前背景图片的文件名或"无图".'''
    如果 图片名 是 空:
        如果 turtle.bgpic() == 'nopic':
            返回 '无图'
        否则:
            返回 turtle.bgpic()
    或如 图片名 == '无图':
        turtle.bgpic('nopic')
    否则:
        试:
            turtle.bgpic(图片名)
        捕:
            报 海龟异常('未找到文件, 或者不是 gif 文件, 或者无法读取文件.')

函 屏幕大小(画布宽度=空, 画布高度=空, 背景颜色=空):
    '''调整海龟绘图所在的画布大小. \n
    如无参数, 则返回当前 (画布宽度, 画布高度).'''
    返回 turtle.screensize(画布宽度, 画布高度, 背景颜色)

函 主循环():
    '''启动事件循环. 必须是海龟绘图程序的最后一条语句.'''
    turtle.mainloop()

完成 = 主循环

函 设置(宽度=0.5, 高度=0.75, 起始x=空, 起始y=空):
    '''设置主窗口的大小和位置.\n
    宽和高：如为一个整型数值，表示大小为多少像素；
    如为一个浮点数值，则表示屏幕的占比；默认为屏幕的 50%。\n
    起始x和y：正值表示初始位置距离屏幕左边缘多少像素，
    负值表示距离右边缘多少像素，空表示窗口水平/垂直居中。
    '''
    turtle.setup(宽度, 高度, 起始x, 起始y)

函 标题(标题字符串):
    '''设置海龟绘图窗口的标题.
    例：海龟.标题('欢迎来到草蟒世界！')
    '''
    turtle.title(标题字符串)

函 再见():
    '''关闭海龟绘图窗口.'''
    turtle.bye()

函 当点击时退出():
    '''进入主循环, 直至点击鼠标.'''
    turtle.exitonclick()

函 屏幕():
    '''返回单例屏幕对象.'''
    返回 turtle.Screen()

_T = TypeVar('_T')

类 海龟类(turtle.Turtle):
    '''用于生产小海龟.'''

    函 设置圆度数(自身, 度数=360.0):
        '''设置一个圆周为多少度。'''
        自身.degrees(度数)

    函 弧度制(自身):
        '''设置角度的度量单位为弧度。'''
        自身.radians()

    函 前进(自身, 距离):
        '''让海龟前进指定距离.'''
        自身.forward(距离)

    函 后退(自身, 距离):
        '''让海龟后退指定距离.'''
        自身.back(距离)

    函 右转(自身, 角度):
        '''让海龟右转指定角度.'''
        自身.right(角度)

    函 左转(自身, 角度):
        '''让海龟左转指定角度.'''
        自身.left(角度)

    函 位置(自身):
        '''返回一个表示海龟当前位置 (x, y) 的二维向量.'''
        返回 自身.pos()

    函 x坐标(自身):
        '''返回海龟的 x 坐标.'''
        返回 自身.xcor()

    函 y坐标(自身):
        '''返回海龟的 y 坐标.'''
        返回 自身.ycor()

    函 前往(自身, x, y=空):
        '''让海龟移动到一个绝对位置.
        如果 y 为空, 则 x 须为一对数 (即元组或二维向量).
        '''
        自身.goto(x, y)

    函 回到原点(自身):
        '''让海龟移动到坐标原点 (0, 0).
        朝向设为起始方向 (取决于模式).
        '''
        自身.home()

    函 设置x(自身, x):
        '''将海龟的第一个坐标设为 x.'''
        自身.setx(x)

    函 设置y(自身, y):
        '''将海龟的第二个坐标设为 y.'''
        自身.sety(y)

    函 距离(自身, x, y=空):
        '''返回海龟到 (x, y) 的距离.'''
        返回 自身.distance(x, y)

    函 目标方向(自身, x, y=空):
        '''返回从海龟到 (x, y) 的直线与起始方向的夹角.'''
        返回 自身.towards(x, y)

    函 朝向(自身):
        '''返回海龟当前朝向.'''
        返回 自身.heading()

    函 设置朝向(自身, 角度):
        '''让海龟朝向指定角度.'''
        自身.setheading(角度)

    函 画圆(自身, 半径, 圆弧度数=空, 边数=空):
        '''绘制一个指定半径的圆，半径为正值时圆心在海龟左边，
        半径为负值时圆心在海龟右边，起点为海龟当前位置。\n
        <圆弧度数>决定绘制圆的多大部分，如未指定则绘制整个圆，
        否则以当前位置为一个端点绘制圆弧。\n
        如果半径为正值, 则朝逆时针方向绘制圆弧，否则朝顺时针方向绘制。\n
        最终海龟的朝向会依据<圆弧度数>的值而改变。\n
        圆实际是以其内切正多边形来近似表示的，其边的数量由<边数>
        指定，如未指定边数则自动确定。此方法也可用来绘制正多边形。
        '''
        自身.circle(半径, 圆弧度数, 边数)

    函 速度(自身, 速度值=空):
        '''<速度>参数为 0 - 10 范围内的整数。如未指定参数则返回当前速度。\n
        如果输入数值大于 10 或小于 0.5，则速度设为 0。\n
        速度字符串与速度值的对应关系如下：\n
        0：最快，无动画效果；10：快；6：正常；3：慢；1：最慢
        '''
        返回 自身.speed(速度值)

    函 大小调整模式(自身, 调整模式=空):
        '''返回或设置大小调整模式，选项有三个：
        '自动' ('auto')、'用户' ('user')、'不调整' ('noresize')。
        '''
        如果 调整模式 是 空:            
            返回 _调整模式字典英中[自身.resizemode()]
        自身.resizemode(_调整模式字典.获取(调整模式, 调整模式))

    函 画笔粗细(自身, 粗细=空):
        '''设置或返回线条粗细.'''
        返回 自身.pensize(粗细)

    函 画笔抬起(自身):
        '''抬起画笔, 移动时不绘图.'''
        自身.penup()

    函 画笔落下(自身):
        '''放下画笔, 移动时绘图.'''
        自身.pendown()

    函 画笔是否落下(自身):
        '''判断画笔当前状态, 如落下则返回<True>,否则返回<False>.'''
        返回 自身.isdown()

    函 颜色(自身, *参数):
        '''返回或设置画笔颜色及填充颜色.'''
        如果 参数:
            长度 = 长(参数)
            i = 0
            参数列表 = 列表(参数)
            只要 i < 长度:
                如果 是实例(参数列表[i], 串):
                    参数列表[i] = _颜色字典.获取(参数列表[i], 参数列表[i])
                i += 1
            参数 = 元组(参数列表)
            自身.color(*参数)
        否则:
            返回 (_颜色字典英中.获取(自身.color()[0], 自身.color()[0]),
                    _颜色字典英中.获取(自身.color()[1], 自身.color()[1]))

    函 画笔颜色(自身, *参数):
        '''返回或设置画笔颜色.
        '''
        如果 非 参数:
            返回 _颜色字典英中.获取(自身.pencolor(), 自身.pencolor())
        或如 长(参数) == 1:
            试:
                参数_ = _颜色字典[参数[0]]
                自身.pencolor(参数_)
            捕:
                自身.pencolor(*参数)
        否则:
            自身.pencolor(*参数)

    函 填充颜色(自身, *参数):
        '''返回或设置填充颜色.
        '''
        如果 非 参数:
            返回 _颜色字典英中.获取(自身.fillcolor(), 自身.fillcolor())
        或如 长(参数) == 1:
            试:
                参数_ = _颜色字典[参数[0]]
                自身.fillcolor(参数_)
            捕:
                自身.fillcolor(*参数)
        否则:
            自身.fillcolor(*参数)

    函 显示海龟(自身):
        '''让海龟可见.'''
        自身.showturtle()

    函 隐藏海龟(自身):
        '''让海龟不可见.'''
        自身.hideturtle()

    函 是否可见(自身):
        '''如果海龟可见, 返回<True>, 否则返回<False>.'''
        返回 自身.isvisible()

    函 画笔(自身, 画笔=空, **画笔字典):
        '''返回或设置画笔属性. <画笔>为包含下列部分或全部键的字典；
        <画笔字典>为一个或多个以下列键为关键字的关键字参数。\n
        '显示' ('shown'): 真/假；\n
        '画笔落下' ('pendown'): 真/假；\n
        '画笔颜色' ('pencolor'): 颜色字符串或颜色元组；\n
        '填充颜色' ('fillcolor'): 颜色字符串或颜色元组；\n
        '画笔粗细' ('pensize'): 正数值；\n
        '速度' ('speed'): 0-10 范围内的数值；\n
        '大小调整模式' ('resizemode'): '自动' ('auto') 或 '用户' ('user') 或 '不调整' ('noresize')；\n
        '伸缩因子' ('stretchfactor'): (正数值, 正数值)；\n
        '伸缩因子' ('shearfactor'): 数值；\n
        '轮廓宽度' ('outline'): 正数值；\n
        '倾斜' ('tilt'): 数值\n
        此字典可作为后续调用“画笔()” 时的参数，以恢复之前的画笔状态。
        另外还可将这些属性作为关键词参数提交。使用此方式可以用一条语句设置画笔的多个属性。
        '''
        _pd =  {"显示"          : 自身._shown,
                "画笔落下"      : 自身._drawing,
                "画笔颜色"      : _颜色字典英中.获取(自身._pencolor, 自身._pencolor),
                "填充颜色"      : _颜色字典英中.获取(自身._fillcolor, 自身._fillcolor),
                "画笔粗细"      : 自身._pensize,
                "速度"          : 自身._speed,
                "大小调整模式"   : _调整模式字典英中[自身._resizemode],
                "伸缩因子"      : 自身._stretchfactor,
                "剪切因子"      : 自身._shearfactor,
                "轮廓宽度"          : 自身._outlinewidth,
                "倾斜"          : 自身._tilt
        }
        如果 非 (画笔 或 画笔字典):
            返回 _pd
        参数字典 = {
                "显示"          : "shown",
                "画笔落下"      : "pendown",
                "画笔颜色"      : "pencolor",
                "填充颜色"      : "fillcolor",
                "画笔粗细"      : "pensize",
                "速度"          : "speed",
                "大小调整模式"   : "resizemode",
                "伸缩因子"      : "stretchfactor",
                "剪切因子"      : "shearfactor",
                "轮廓宽度"      : "outline",
                "倾斜"          : "tilt"
        }
        参数值字典 = {**_颜色字典, **_调整模式字典}
        新画笔 = {}
        如果 画笔 不是 空:
            取 键, 值 于 画笔.项():
                键 = 参数字典.获取(键, 键)
                值 = 参数值字典.获取(值, 值)
                新画笔[键] = 值
        新画笔字典 = {}
        取 键, 值 于 画笔字典.项():
            键 = 参数字典.获取(键, 键)
            值 = 参数值字典.获取(值, 值)
            新画笔字典[键] = 值
        自身.pen(新画笔, **新画笔字典)

    函 重置(自身):
        '''删除海龟绘图并恢复其默认值.'''
        自身.reset()

    函 设置撤消缓冲区(自身, 大小):
        '''设置或禁用撤消缓冲区.\n
        <大小> -- 整数或空.\n
        如果<大小>为整数, 则会创建一个空的指定大小的撤消缓冲区.
        <撤消()> 函数最多可以撤消指定数量的海龟操作.\n
        如果<大小>为空, 则不存在撤消缓冲区.
        '''
        自身.setundobuffer(大小)

    函 撤消缓冲区条目数(自身):
        '''返回撤消缓冲区中的条目数.'''
        返回 自身.undobufferentries()

    函 清除(自身):
        '''从屏幕上删除海龟绘图, 但不移动海龟.\n
        海龟的状态和位置以及其他海龟的绘图不受影响.'''
        自身.clear()

    函 克隆(自身: _T) -> _T:
        '''创建并返回海龟的克隆体, 其与原海龟具有相同的位置、朝向和属性.'''
        返回 自身.clone()

    函 形状(自身, 名称=空):
        '''将海龟形状设置为指定名称的形状, 或返回当前形状名称.'''
        如果 名称 是 空:
            返回 _形状字典英中.获取(自身.shape(), 自身.shape())
        名称 = _形状字典.获取(名称, 名称)
        如果 名称 不在 自身.screen.getshapes():
            报 Exception("没有名为 %s 的形状" % 名称)
        自身.shape(名称)           

    函 形状大小(自身, 宽度伸缩因子=空, 长度伸缩因子=空, 轮廓=空):
        '''返回或设置海龟 (画笔) 的形状属性。'''
        返回 自身.shapesize(宽度伸缩因子, 长度伸缩因子, 轮廓)

    函 剪切因子(自身, 剪切值=空):
        '''设置或返回 (如未指定参数值) 当前的剪切形变因子。'''
        返回 自身.shearfactor(剪切值)

    函 设置倾角(自身, 角度):
        '''旋转海龟形状使其指向指定角度的方向，忽略其当前的倾角，
        不改变海龟的朝向 (移动方向)。'''
        自身.settiltangle(角度)

    函 倾斜(自身, 角度):
        '''海龟形状自其当前倾角转动指定的角度，但不改变朝向 (移动方向)。'''
        自身.tilt(角度)

    函 变形(自身, t11=空, t12=空, t21=空, t22=空):
        '''设置或返回海龟形状的变形矩阵。'''
        返回 自身.shapetransform(t11, t12, t21, t22)

    函 获取形状多边形(自身):
        '''返回以坐标值对表示的当前形状多边形。
        这可以用于定义一个新形状或一个复合形状的多个组成部分。'''
        返回 自身.get_shapepoly()

    函 印章(自身):
        '''在海龟当前位置印制一个海龟形状，返回该印章的 ID。'''
        返回 自身.stamp()

    函 清除印章(自身, 印章ID):
        '''清除指定ID的印章。印章 ID为整型数。'''
        自身.clearstamp(印章ID)

    函 清除多个印章(自身, n=空):
        '''清除全部或前/后 n 个印章。如果 n 为 空则清除全部印章.\n
        如果 n > 0 则清除前 n 个印章; 否则如果 n < 0 则清除后 n 个印章。
        '''
        自身.clearstamps(n)

    函 是否在填充(自身):
        '''返回填充状态.'''
        返回 自身.filling()

    函 开始填充(自身):
        '''在绘制要填充的形状之前调用.'''
        自身.begin_fill()

    函 结束填充(自身):
        '''填充所绘制的形状, 与<开始填充>配合使用.'''
        自身.end_fill()

    函 画点(自身, 大小=空, *颜色):
        '''绘制一个指定大小（直径）和颜色的点。\n
        如果未指定大小，则直径取 <画笔粗细+4> 和 <2*画笔粗细> 中的较大值。\n
        颜色可以是表示颜色的字符串或颜色数值元组，如未指定则取默认颜色。
        '''
        如果 长(颜色) == 1:
            试:
                颜色_ = _颜色字典[颜色[0]]
                自身.dot(大小, 颜色_)
            捕:
                自身.dot(大小, *颜色)
        否则:
            自身.dot(大小, *颜色)

    函 书写(自身, 内容, 是否移动=假, 对齐='左', 字体=('Arial', 8, '正常')):
        '''在当前海龟位置书写文本. 内容可以是纯数值、字符串或元组、列表、字典等对象。\n
        <是否移动>参数若为<真>，则海龟随着书写内容向前移动，默认值为<假>。\n
        <对齐>方式可以选择<'左'>、<'居中'>或<'右'>，默认为<'左'>。\n
        字体用三元元组表示，默认为 ('Arial', 8, '正常')；
        字体的第三个选项除 '正常' 外，还可以选择 '粗体' 或 '斜体'。\n
        还可以有第四个、第五个等等选项，设置同第三个选项，
        比如：字体=('Arial', 12, '粗体', '斜体').
        '''
        对齐字典 = 字典(左='left', 右='right', 居中='center')
        对齐 = 对齐字典.获取(对齐, 对齐)
        字体样式字典 = 字典(正常='normal', 粗体='bold', 斜体='italic')
        如果 长(字体) >= 3:
            字体参数列表 = 列表(字体)
            i = 0
            只要 i < 长(字体) - 2:
                字体参数列表[i+2] = 字体样式字典.获取(字体参数列表[i+2], 字体参数列表[i+2])
                i += 1
            字体 = 元组(字体参数列表)
        自身.write(内容, 是否移动, 对齐, 字体)

    函 开始记录多边形(自身):
        '''当前海龟位置为多边形的第一个顶点。'''
        自身.begin_poly()

    函 结束记录多边形(自身):
        '''当前海龟位置为多边形的最后一个顶点。它将连线到第一个顶点。'''
        自身.end_poly()

    函 获取多边形(自身):
        '''返回最新记录的多边形。'''
        返回 自身.get_poly()

    函 获取屏幕(自身):
        '''返回海龟绘图所在的屏幕对象.'''
        返回 自身.getscreen()

    函 获取海龟(自身: _T) -> _T:
        '''返回海龟对象本身.'''
        返回 自身.getturtle()

    函 当点击鼠标(自身, 函数名, 鼠标键=1, 是否添加绑定=空):
        '''将函数绑定到鼠标点击海龟事件.\n
        第一个参数表示事件绑定的函数，系统会自动给它传递两个参数，
        即在画布上点击的坐标；注意是填入函数名，不要加括号；
        如果函数名为空，则移除现有的绑定。\n
        第二个参数的默认值为 1（鼠标左键），还可以选择 2（鼠标中键）或 3（鼠标右键）.\n
        第三个参数填入<真>或<假>，如为真则将添加一个新绑定，否则将取代先前的绑定（默认值）。\n
        注意：在海龟上拖动鼠标之前会先发生在此海龟上点击鼠标事件。
        '''
        自身.onclick(函数名, 鼠标键, 是否添加绑定)

    函 当释放鼠标(自身, 函数名, 鼠标键=1, 是否添加绑定=空):
        '''将函数绑定到鼠标释放事件.
        参数说明见 <当点击鼠标()> 函数.
        '''
        自身.onrelease(函数名, 鼠标键, 是否添加绑定)

    函 当拖动鼠标(自身, 函数名, 鼠标键=1, 是否添加绑定=空):
        '''将函数绑定到鼠标拖动海龟事件.
        参数说明见 <当点击鼠标()> 函数.
        '''
        自身.ondrag(函数名, 鼠标键, 是否添加绑定)

    函 撤消(自身):
        '''(重复)撤消海龟最后一次动作.'''
        自身.undo()

_ttl = 海龟类()
后退 = _ttl.后退
开始填充 = _ttl.开始填充
开始记录多边形 = _ttl.开始记录多边形
画圆 = _ttl.画圆
清除 = _ttl.清除
清除印章 = _ttl.清除印章
清除多个印章 = _ttl.清除多个印章
克隆 = _ttl.克隆
颜色 = _ttl.颜色
设置圆度数 = _ttl.设置圆度数
距离 = _ttl.距离
画点 = _ttl.画点
画笔落下 = _ttl.画笔落下
结束填充 = _ttl.结束填充
结束记录多边形 = _ttl.结束记录多边形
前进 = _ttl.前进
填充颜色 = _ttl.填充颜色
是否在填充 = _ttl.是否在填充
获取多边形 = _ttl.获取多边形
获取海龟 = _ttl.获取海龟
获取屏幕 = _ttl.获取屏幕
获取形状多边形 = _ttl.获取形状多边形
前往 = _ttl.前往
朝向 = _ttl.朝向
隐藏海龟 = _ttl.隐藏海龟
回到原点 = _ttl.回到原点
画笔是否落下 = _ttl.画笔是否落下
是否可见 = _ttl.是否可见
左转 = _ttl.左转
当点击鼠标 = _ttl.当点击鼠标
当拖动鼠标 = _ttl.当拖动鼠标
当释放鼠标 = _ttl.当释放鼠标
画笔 = _ttl.画笔
画笔颜色 = _ttl.画笔颜色
画笔粗细 = _ttl.画笔粗细
画笔抬起 = _ttl.画笔抬起
位置 = _ttl.位置
弧度制 = _ttl.弧度制
右转 = _ttl.右转
重置 = _ttl.重置
大小调整模式 = _ttl.大小调整模式
设置朝向 = _ttl.设置朝向
设置倾角 = _ttl.设置倾角
设置撤消缓冲区 = _ttl.设置撤消缓冲区
设置x = _ttl.设置x
设置y = _ttl.设置y
形状 = _ttl.形状
形状大小 = _ttl.形状大小
变形 = _ttl.变形
剪切因子 = _ttl.剪切因子
显示海龟 = _ttl.显示海龟
速度 = _ttl.速度
印章 = _ttl.印章
倾斜 = _ttl.倾斜
目标方向 = _ttl.目标方向
撤消 = _ttl.撤消
撤消缓冲区条目数 = _ttl.撤消缓冲区条目数
书写 = _ttl.书写
x坐标 = _ttl.x坐标
y坐标 = _ttl.y坐标


